/**
 * 状态处理辅助模块
 * 用于项目状态字段的标准化处理
 * 确保"新建项目-->云端数据库-->项目列表-->项目详情"流程中状态一致性
 */

// 尝试加载项目模型定义
let ResearchProjectModel = null;
try {
  ResearchProjectModel = require('../model/research_project_model');
  console.log('成功加载项目模型: ../model/research_project_model');
} catch (e) {
  console.warn('加载项目模型失败: ../model/research_project_model', e);
  try {
    ResearchProjectModel = require('../model/project_model').ResearchProjectModel;
    console.log('成功加载项目模型: ../model/project_model');
  } catch (e) {
    console.error('所有项目模型加载失败，状态处理功能将受限', e);
  }
}

// 状态流转日志记录
const stateTransitionLogs = new Map();

/**
 * 记录状态流转日志
 * @param {string} projectId 项目ID
 * @param {Object} fromState 原状态
 * @param {Object} toState 目标状态
 * @param {string} operator 操作人
 * @param {string} reason 变更原因
 */
function logStateTransition(projectId, fromState, toState, operator, reason) {
  try {
    if (!projectId) return;
    
    const log = {
      timestamp: Date.now(),
      fromState,
      toState,
      operator,
      reason,
      projectId
    };
    
    // 获取项目日志
    let projectLogs = stateTransitionLogs.get(projectId) || [];
    projectLogs.push(log);
    
    // 限制日志数量
    if (projectLogs.length > 100) {
      projectLogs = projectLogs.slice(-100);
    }
    
    // 更新日志
    stateTransitionLogs.set(projectId, projectLogs);
    
    // 触发状态变更通知
    notifyStateChange(projectId, fromState, toState, operator);
  } catch (error) {
    console.error('记录状态流转日志失败:', error);
  }
}

/**
 * 获取状态流转日志
 * @param {string} projectId 项目ID
 * @returns {Array} 状态流转日志
 */
function getStateTransitionLogs(projectId) {
  return stateTransitionLogs.get(projectId) || [];
}

/**
 * 触发状态变更通知
 * @param {string} projectId 项目ID
 * @param {Object} fromState 原状态
 * @param {Object} toState 目标状态
 * @param {string} operator 操作人
 */
function notifyStateChange(projectId, fromState, toState, operator) {
  try {
    // 获取项目信息
    const project = getProjectInfo(projectId);
    if (!project) return;
    
    // 构建通知内容
    const notification = {
      type: 'state_change',
      projectId,
      projectName: project.name,
      fromState: getStatusText(fromState.level1, fromState.level2),
      toState: getStatusText(toState.level1, toState.level2),
      operator,
      timestamp: Date.now()
    };
    
    // 发送通知
    sendNotification(notification);
  } catch (error) {
    console.error('触发状态变更通知失败:', error);
  }
}

/**
 * 检查状态依赖
 * @param {Object} project 项目数据
 * @param {Object} targetState 目标状态
 * @returns {Object} 检查结果
 */
function checkStateDependencies(project, targetState) {
  try {
    if (!project || !targetState) {
      return {
        valid: false,
        reason: '参数不完整'
      };
    }
    
    // 获取状态依赖规则
    const dependencies = ResearchProjectModel?.STATE_DEPENDENCIES;
    if (!dependencies) {
      return {
        valid: true,
        reason: '无依赖规则'
      };
    }
    
    // 检查目标状态的依赖规则
    const targetKey = `${targetState.level1}-${targetState.level2}`;
    const rules = dependencies[targetKey];
    
    if (!rules) {
      return {
        valid: true,
        reason: '无依赖规则'
      };
    }
    
    // 检查每个依赖条件
    for (const rule of rules) {
      const { field, value, message } = rule;
      
      // 检查字段值
      if (project[field] !== value) {
        return {
          valid: false,
          reason: message || `不满足状态依赖条件: ${field}`
        };
      }
    }
    
    return {
      valid: true,
      reason: '满足所有依赖条件'
    };
  } catch (error) {
    console.error('检查状态依赖失败:', error);
    return {
      valid: false,
      reason: '检查过程出错'
    };
  }
}

/**
 * 获取状态文本
 * @param {number} level1 一级状态
 * @param {string} level2 二级状态
 * @returns {string} 状态文本
 */
function getStatusText(level1, level2) {
  const statusName = getLevel1StatusName(level1);
  const subStatusName = getLevel2StatusName(level1, level2);
  
  if (subStatusName) {
    return `${statusName}-${subStatusName}`;
  }
  return statusName;
}

/**
 * 获取完整状态描述
 * @param {Object} project 项目数据
 * @returns {string} 完整状态描述
 */
function getFullStatusDesc(project) {
  if (!project) return '未知状态';
  
  const level1 = project.level1;
  const level2 = project.level2;
  const level3 = project.level3;
  const level4 = project.level4;
  
  // 获取一级状态名称
  let desc = getLevel1StatusName(level1);
  
  // 添加二级状态
  if (level2) {
    const subStatusName = getLevel2StatusName(level1, level2);
    if (subStatusName) {
      desc += ` > ${subStatusName}`;
    }
  }
  
  // 添加三级状态
  if (level3) {
    const level3StatusName = getLevel3StatusName(level3);
    if (level3StatusName) {
      desc += ` > ${level3StatusName}`;
    }
  }
  
  // 添加四级状态
  if (level4) {
    const level4StatusName = getLevel4StatusName(level3, level4);
    if (level4StatusName) {
      desc += ` > ${level4StatusName}`;
    }
  }
  
  return desc;
}

/**
 * 获取一级状态名称
 * @param {number} level1 一级状态值
 * @returns {string} 一级状态名称
 */
function getLevel1StatusName(level1) {
  const statusMap = {
    1: '项目审核',
    2: '硬件设计',
    3: '软件调试',
    4: '测试',
    5: '客户验证',
    6: '订单准备',
    7: '生产',
    8: '待反馈',
    9: '休眠'
  };
  
  return statusMap[level1] || '未知状态';
}

/**
 * 获取二级状态名称
 * @param {number} level1 一级状态值
 * @param {string} level2 二级状态值
 * @returns {string} 二级状态名称
 */
function getLevel2StatusName(level1, level2) {
  // 根据一级状态获取对应的二级状态映射
  const level2Maps = {
    1: { // 项目审核
      'director': '董事长',
      'manager': '研发经理',
      'assign': '分配',
    },
    2: { // 硬件设计
      'design': '设计',
      'review': '审核',
      'proto': '打样',
      'sample': '制样',
      'stock': '在库'
    },
    3: { // 软件调试
      'debug': '调试',
      'sync': '资料同步'
    },
    4: { // 测试
      'testing': '测试中',
      'without': '无测审核'
    },
    5: { // 客户验证
      'send': '寄样',
      'test': '测试',
      'sample': '样品在库',
      'archive': '归档'
    },
    6: { // 订单准备
      'wait': '待量产',
      'review': '审核',
      'document': '文控',
      'supplement': '补充资料',
      'meeting': '产前会',
      'prepare': '生产准备'
    },
    7: { // 生产
      'producing': '生产中',
      'pe': 'PE处理',
      'rd': '研发排查',
      'complete': '完成'
    },
    8: { // 待反馈
      'feedback': '反馈中'
    },
    9: { // 休眠
      'review': '审核',
      'archive': '归档'
    }
  };
  
  // 获取对应的二级状态映射
  const stateMap = level2Maps[level1] || {};
  return stateMap[level2] || '';
}

/**
 * 获取三级状态名称
 * @param {string} level3 三级状态值
 * @returns {string} 三级状态名称
 */
function getLevel3StatusName(level3) {
  // 三级状态通常表示更细粒度的流程状态
  const level3Map = {
    'hwConfirm': '硬件确认',
    'hwDesign': '硬件设计',
    'swDebug': '软件调试',
    'test': '测试',
    'customerConfirm': '客户确认',
    'orderPrepare': '订单准备',
    'production': '生产',
    'waitFeedback': '待反馈',
    'archived': '已归档'
  };
  
  return level3Map[level3] || '';
}

/**
 * 获取四级状态名称
 * @param {string} level3 三级状态值
 * @param {string} level4 四级状态值
 * @returns {string} 四级状态名称
 */
function getLevel4StatusName(level3, level4) {
  // 四级状态根据三级状态有不同的映射关系
  const level4Maps = {
    'hwDesign': {
      'drawing': '绘制原理图',
      'layout': '布局PCB',
      'check': '自检',
      'submit': '提交审核'
    },
    'swDebug': {
      'developing': '开发中',
      'unitTest': '单元测试',
      'integration': '集成测试',
      'submit': '提交测试'
    },
    'test': {
      'prepare': '准备测试用例',
      'exec': '执行测试',
      'fix': '修复问题',
      'verify': '验证修复',
      'complete': '测试完成'
    }
  };
  
  // 获取对应的四级状态映射
  const stateMap = level4Maps[level3] || {};
  return stateMap[level4] || '';
}

/**
 * 获取开发状态文本
 * @param {Object} project 项目数据
 * @returns {string} 开发状态描述
 */
function getDevelopmentStatus(project) {
  if (!project) return '未知状态';
  
  const level1 = project.level1;
  
  // 根据一级状态获取开发状态
  const statusMap = {
    1: '待立项',
    2: '开发中',
    3: '开发中',
    4: '测试中',
    5: '送样阶段',
    6: '量产中',
    7: '生产中',
    8: '已完成',
    9: '已休眠'
  };
  
  return statusMap[level1] || '未知状态';
}

/**
 * 获取状态进度颜色
 * @param {Object} project 项目数据
 * @returns {string} 颜色代码
 */
function getStatusColor(project) {
  try {
    if (!project) return '#9e9e9e'; // 灰色
    
    // 根据一级状态确定颜色
    const level1 = project.level1;
    
    if (level1 === 1) return '#3f51b5'; // 靛蓝色 - 待立项
    if (level1 === 2) return '#9e9e9e'; // 灰色 - 休眠
    if (level1 === 3) return '#4caf50'; // 绿色 - 活动
    if (level1 === 4) return '#ff9800'; // 橙色 - 暂停
    if (level1 === 5) return '#ff5722'; // 深橙色 - 延期
    if (level1 === 6) return '#795548'; // 棕色 - 搁置
    if (level1 === 99) return '#2196f3'; // 蓝色 - 完成
    
    return '#9e9e9e'; // 灰色 - 默认
  } catch (error) {
    console.error('getStatusColor获取失败:', error);
    return '#9e9e9e'; // 灰色
  }
}

/**
 * 获取项目完成度百分比
 * @param {Object} project 项目数据
 * @returns {number} 完成度百分比
 */
function getCompletionPercentage(project) {
  try {
    if (!project) return 0;
    
    // 如果已有完成度字段，直接返回
    if (typeof project.completionPercentage === 'number') {
      return project.completionPercentage;
    }
    
    // 根据一级状态估算完成度
    const level1 = project.level1;
    const level2 = project.level2;
    
    // 已完成状态
    if (level1 === 99) return 100;
    
    // 待立项状态
    if (level1 === 1) {
      // 根据二级状态细分
      if (level2 === 'director') return 0; // 董事长审批
      if (level2 === 'manager') return 10; // 经理审批
      if (level2 === 'leader') return 15; // 组长审批
      return 5; // 默认
    }
    
    // 活动状态
    if (level1 === 3) {
      // 根据二级状态细分
      if (level2 === 'planning') return 20; // 规划阶段
      if (level2 === 'design') return 40; // 设计阶段
      if (level2 === 'development') return 60; // 开发阶段
      if (level2 === 'testing') return 80; // 测试阶段
      if (level2 === 'validation') return 90; // 验证阶段
      return 50; // 默认
    }
    
    // 其他状态
    if (level1 === 2) return 20; // 休眠状态
    if (level1 === 4) return 45; // 暂停状态
    if (level1 === 5) return 45; // 延期状态
    if (level1 === 6) return 30; // 搁置状态
    
    return 0; // 默认
  } catch (error) {
    console.error('getCompletionPercentage计算失败:', error);
    return 0;
  }
}

/**
 * 判断当前状态是否可以流转到目标状态
 * @param {Object} currentStatus 当前状态对象 {level1, level2, level3, level4}
 * @param {Object} targetStatus 目标状态对象 {level1, level2, level3, level4}
 * @returns {Object} 包含是否可流转及原因的对象
 */
function canTransition(currentStatus, targetStatus) {
  try {
    if (!ResearchProjectModel) {
      console.warn('项目模型未加载，无法验证状态流转');
      return { 
        canTransition: false, 
        reason: '状态流转规则未加载' 
      };
    }
    
    // 获取状态转换规则
    const transitions = ResearchProjectModel.STATE_TRANSITIONS;
    if (!transitions) {
      return { 
        canTransition: false, 
        reason: '状态流转规则未定义' 
      };
    }
    
    // 如果未提供当前状态或目标状态
    if (!currentStatus || !targetStatus) {
      return { 
        canTransition: false, 
        reason: '状态参数不完整' 
      };
    }
    
    // 获取当前一级和二级状态
    const currentLevel1 = currentStatus.level1;
    const currentLevel2 = currentStatus.level2;
    
    // 检查当前状态的流转规则是否存在
    if (!transitions[currentLevel1] || !transitions[currentLevel1][currentLevel2]) {
      return { 
        canTransition: false, 
        reason: `当前状态没有流转规则: ${currentLevel1}-${currentLevel2}` 
      };
    }
    
    // 获取当前状态下的所有可能流转结果
    const possibleTransitions = transitions[currentLevel1][currentLevel2];
    
    // 检查目标状态是否在可能流转结果中
    const targetKey = `${targetStatus.level1}-${targetStatus.level2}`;
    const canTransition = Object.values(possibleTransitions).some(
      transition => `${transition.level1}-${transition.level2}` === targetKey
    );
    
    return {
      canTransition,
      reason: canTransition ? '可以流转' : '目标状态不在允许的流转范围内'
    };
  } catch (error) {
    console.error('canTransition检查失败:', error);
    return {
      canTransition: false,
      reason: '检查过程出错'
    };
  }
}

/**
 * 获取项目下一步可能的状态流转选项
 * @param {Object} project 项目数据
 * @returns {Array} 可能的状态流转选项数组
 */
function getNextStatusOptions(project) {
  try {
    if (!project) return [];
    
    if (!ResearchProjectModel) {
      console.warn('项目模型未加载，无法获取下一步状态选项');
      return [];
    }
    
    // 获取状态转换规则
    const transitions = ResearchProjectModel.STATE_TRANSITIONS;
    if (!transitions) return [];
    
    // 获取当前状态
    const level1 = project.level1;
    const level2 = project.level2;
    
    // 检查当前状态的流转规则是否存在
    if (!transitions[level1] || !transitions[level1][level2]) {
      return [];
    }
    
    // 获取当前状态下的所有可能流转事件
    const possibleTransitions = transitions[level1][level2];
    
    // 构建流转选项数组
    const options = [];
    for (const event in possibleTransitions) {
      const transitionResult = possibleTransitions[event];
      
      // 获取目标状态的名称
      let targetStatusName = '';
      if (ResearchProjectModel.LEVEL_1_NAMES[transitionResult.level1]) {
        targetStatusName = ResearchProjectModel.LEVEL_1_NAMES[transitionResult.level1];
        
        if (transitionResult.level2 && ResearchProjectModel.LEVEL_2_NAMES[transitionResult.level2]) {
          targetStatusName += ' > ' + ResearchProjectModel.LEVEL_2_NAMES[transitionResult.level2];
        }
      } else {
        targetStatusName = `状态${transitionResult.level1}`;
      }
      
      options.push({
        event: event,
        targetStatus: transitionResult,
        targetStatusName: targetStatusName,
        // 根据事件类型提供中文名称
        eventName: getEventName(event)
      });
    }
    
    return options;
  } catch (error) {
    console.error('getNextStatusOptions获取失败:', error);
    return [];
  }
}

/**
 * 获取事件名称
 * @param {string} event 事件标识
 * @returns {string} 事件名称
 */
function getEventName(event) {
  const eventMap = {
    'submit': '提交',
    'approve': '审批',
    'reject': '驳回',
    'activate': '激活',
    'suspend': '暂停',
    'resume': '恢复',
    'complete': '完成',
    'cancel': '取消'
  };
  
  return eventMap[event] || event;
}

/**
 * 获取状态背景颜色
 * @param {number|object} status 状态值或项目对象
 * @returns {string} 状态背景颜色
 */
function getStatusBgColor(status) {
  try {
    // 如果是对象，获取一级状态值
    const level1 = typeof status === 'object' ? status.level1 : status;
    
    // 根据一级状态确定背景颜色
    const statusBgColorMap = {
      0: '#f0f0f0', // 草稿
      1: '#e6f7ff', // 项目审核
      2: '#f6ffed', // 硬件设计
      3: '#f9f0ff', // 软件调试
      4: '#fff7e6', // 测试
      5: '#fff0f6', // 客户验证
      6: '#f0f9ff', // 订单准备
      7: '#f0f0f0', // 生产
      8: '#f6ffed', // 待反馈
      9: '#fff1f0', // 休眠
      99: '#f5f5f5' // 已取消
    };
    
    // 直接从状态映射表返回颜色
    return statusBgColorMap[level1] || '#f5f5f5'; // 默认为淡灰色
  } catch (error) {
    console.error('getStatusBgColor获取失败:', error);
    return '#f5f5f5'; // 淡灰色
  }
}

/**
 * 获取进度颜色
 * @param {number} progress 进度百分比
 * @returns {string} 进度颜色
 */
function getProgressColor(progress) {
  try {
    if (progress >= 100) return '#4caf50'; // 绿色 - 完成
    if (progress >= 75) return '#8bc34a';  // 浅绿色 - 接近完成
    if (progress >= 50) return '#ffc107';  // 琥珀色 - 一半完成
    if (progress >= 25) return '#ff9800';  // 橙色 - 开始阶段
    return '#f44336';  // 红色 - 初始阶段
  } catch (error) {
    console.error('getProgressColor获取失败:', error);
    return '#9e9e9e'; // 灰色
  }
}

module.exports = {
  getStatusText,
  getFullStatusDesc,
  getDevelopmentStatus,
  getStatusColor,
  getStatusBgColor,
  getProgressColor,
  getCompletionPercentage,
  canTransition,
  getNextStatusOptions,
  getEventName,
  logStateTransition,
  getStateTransitionLogs,
  checkStateDependencies,
  getLevel1StatusName,
  getLevel2StatusName,
  getLevel3StatusName,
  getLevel4StatusName
}; 